The Guided Improvement Algorithm for Exact, General-Purpose, Many-Objective Combinatorial Optimization

This paper presents a new general-purpose algorithm for exact solving of combinatorial many-objective optimization problems. We call this new algorithm the guided improvement algorithm. The algorithm is implemented on top of the non-optimizing relational constraint solver Kodkod. We compare the performance of this new algorithm against two algorithms from the literature [Gavanelli 2002, Lukasiewycz et alia 2007, Laumanns et alia 2006]) on three micro-benchmark problems (n-Queens, n-Rooks, and knapsack) and on two aerospace case studies. Results indicate that the new algorithm is better for the kinds of many-objective problems that our aerospace collaborators are interested in solving. The new algorithm returns Pareto-optimal solutions as it computes

Automating abstraction functions

Thesis (Ph. D.)--Massachusetts Institute of Technology, Dept. of Electrical Engineering and Computer Science, 2010.Cataloged from PDF version of thesis.Includes bibliographical references (p. 109-119).Data abstraction has been the dominant structuring paradigm for programs for decades. The essence of a data abstraction is the abstraction function, which relates the concrete program representation to its abstract meaning. However, abstraction functions are not generally considered to be a part of the executing program. We propose that making abstraction functions an executable part of the program can enable programmers to write clearer and more concise programs with fewer errors. In particular, we show that the object equality and hashing operations (which programmers are required to write), can often be expressed more clearly and more concisely in terms of the abstract state of the object. Getting these methods right has proven to be difficult for programmers at all skill levels, from novice through expert. In a case study of the standard Java libraries we show that rewriting the code with explicit declarative abstraction functions (and generating equality and hashing methods automatically) removed object-contract compliance faults previously found by Pacheco et al. To make abstraction functions part of the executing program we develop four techniques for the dynamic evaluation of abstraction functions written in a declarative first-order logic with relations and transitive closure. We observe that the abstraction functions programmers write in practice may often be viewed as navigation queries on the heap, and two of our techniques exploit this insight to synthesize executable code from declarative abstraction functions. The performance of our research prototype is within striking distance of hand-written code.by Derek F. Rayside.Ph.D

Real-Time Unified Trajectory Planning and Optimal Control for Urban Autonomous Driving Under Static and Dynamic Obstacle Constraints

Trajectory planning and control have historically been separated into two modules in automated driving stacks. Trajectory planning focuses on higher-level tasks like avoiding obstacles and staying on the road surface, whereas the controller tries its best to follow an ever changing reference trajectory. We argue that this separation is (1) flawed due to the mismatch between planned trajectories and what the controller can feasibly execute, and (2) unnecessary due to the flexibility of the model predictive control (MPC) paradigm. Instead, in this paper, we present a unified MPC-based trajectory planning and control scheme that guarantees feasibility with respect to road boundaries, the static and dynamic environment, and enforces passenger comfort constraints. The scheme is evaluated rigorously in a variety of scenarios focused on proving the effectiveness of the optimal control problem (OCP) design and real-time solution methods. The prototype code will be released at https://github.com/WATonomous/control

Unifying Execution of Imperative and Declarative Code

We present a unified environment for running declarative specifications in the context of an imperative object-Oriented programming language. Specifications are Alloy-like, written in first-order relational logic with transitive closure, and the imperative language is Java. By being able to mix imperative code with executable declarative specifications, the user can easily express constraint problems in place, i.e., in terms of the existing data structures and objects on the heap. After a solution is found, the heap is updated to reflect the solution, so the user can continue to manipulate the program heap in the usual imperative way. We show that this approach is not only convenient, but, for certain problems can also outperform a standard imperative implementation. We also present an optimization technique that allowed us to run our tool on heaps with almost 2000 objects

Automatic Visualization of Relational Logic Models

Abstract: The Alloy Analyzer is a software design tool that generates examples of system states and executions from logic models and displays those examples graphically with a visualization facility. Although many users find the visualization indispensable, others are put off by the perceived difficulty of customizing the visualization and the poor quality of default diagrams. Many others do not take full advantage of the customization, usually because they do not understand what customizations are available and how best to apply them. This paper describes techniques for inferring a better initial customization, or theme, entirely automatically, based on the model and on criteria derived from experience with manual customization. A plugin that implements these techniques was applied to a repertoire of models. Each automatically generated theme was compared to an "expert" theme and to the default theme, with a simple metric that quantifies the visual difference between themes. These comparisons, which provide an indication of how closely the plugin can match the expert result, show the generated theme to be superior to the default for most models

Astra Version 1.0: Evaluating Translations from Alloy to SMT-LIB

We present a variety of translation options for converting Alloy to SMT-LIB via Alloy’s Kodkod interface. Our translations, which are implemented in a library that we call Astra, are based on converting the set and relational operations of Alloy into their equivalent in typed first-order logic (TFOL). We investigate and compare the performance of an SMT solver for many translation options. We compare using only one universal type to recovering Alloy type information from the Kod- kod representation and using multiple types in TFOL. We compare a direct translation of the relations to predicates in TFOL to one where we recover functions from their relational form in Kodkod and repre- sent these as functions in TFOL. We compare representations in TFOL with unbounded scopes to ones with bounded scopes, either pre or post quantifier expansion. Our results across all these dimensions provide di- rections for portfolio solvers, modelling improvements, and optimizing SMT solvers

A sensorless state estimation for a safety-oriented cyber-physical system in urban driving : deep learning approach

In today's modern electric vehicles, enhancing the safety-critical cyber-physical system CPS 's performance is necessary for the safe maneuverability of the vehicle. As a typical CPS, the braking system is crucial for the vehicle design and safe control. However, precise state estimation of the brake pressure is desired to perform safe driving with a high degree of autonomy. In this paper, a sensorless state estimation technique of the vehicle's brake pressure is developed using a deep-learning approach. A deep neural network DNN is structured and trained using deep-learning training techniques, such as, dropout and rectified units. These techniques are utilized to obtain more accurate model for brake pressure state estimation applications. The proposed model is trained using real experimental training data which were collected via conducting real vehicle testing. The vehicle was attached to a chassis dynamometer while the brake pressure data were collected under random driving cycles. Based on these experimental data, the DNN is trained and the performance of the proposed state estimation approach is validated accordingly. The results demonstrate high-accuracy brake pressure state estimation with RMSE of 0.048 MPa.Published versio

Visualizing Flow Diagrams with SHriMP

This paper focuses on the changes that we have made to SHriMP to accomodate these terminal

1 Extracting Java Library Subsets for Deployment on Embedded Systems

Embedded systems provide means for enhancing the functionality delivered by small-sized electronic devices such as hand-held computers and cellular phones. Java is a programming language which incorporates a number of features that are useful for developing such embedded systems. However, the size and the complexity of the Java language and its libraries have slowed its adoption for embedded systems, due to the processing power and storage space limitations found in these systems. A common approach to address storage space limitations is for the vendor to offer special versions of the libraries with reduced functionality and size to meet the constraints of embedded systems. This paper presents a technique that is used for dynamically selecting, on an as needed basis, the subset of library entities that is exactly required for a given Java application to run. This subset can then be down-loaded to the device for execution. The advantage of this approach is that the developer can use arbitrary libraries, instead of being restricted to those which have been adapted for embedded systems by the vendors. A prototype system, that dynamically builds library subsets on an as needed per application basis, has been built and tested on several mid-size Java applications with positive results.

An Aristotelian understanding of Object-Oriented programming

The folklore of the object-oriented programming community at times maintains that object-oriented programming has drawn inspiration from philosophy, specifically that of Aristotle. We investigate this relation, first of all, in the hope of attaining a better understanding of object-oriented programming and, secondly, to explain aspects of Aristotelian logic to the computer science research community (since it differs from first order predicate calculus in a number of important ways). In both respects we endeavour to contribute to the theory of objects, albeit in a more philosophical than mathematical fashion. 1